home *** CD-ROM | disk | FTP | other *** search
/ Otherware / Otherware_1_SB_Development.iso / mac / sysext / cdev / sludge.sit / Sludge v1.0 ƒ / Source Code / Parasite.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-10-07  |  9.7 KB  |  196 lines
  1. /*ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  2.   Ñ                                                                           Ñ
  3.   Ñ   File Name:                                                              Ñ
  4.   Ñ   ----------                                                              Ñ
  5.   Ñ                                                                           Ñ
  6.   Ñ   Copyright ⌐ 1990 Apple Computer, Inc.  All Rights Reserved              Ñ
  7.   Ñ                                                                           Ñ
  8.   Ñ       Description                                                         Ñ
  9.   Ñ       -----------                                                         Ñ
  10.   Ñ       This file contains the c language portion of the parasite.  The     Ñ
  11.   Ñ          parasite is what slows down your mac.                                  Ñ
  12.   Ñ                                                                           Ñ
  13.   Ñ       History                                                             Ñ
  14.   Ñ       -------                                                             Ñ
  15.   Ñ                                                                           Ñ
  16.   Ñ       Author          Date            Description                         Ñ
  17.   Ñ       ------------------------------------------------------------------  Ñ
  18.   Ñ       Kevin McEntee   2/20/90         Original Implementation             Ñ
  19.   Ñ                                                                           Ñ
  20.   Ñ                                                                           Ñ
  21.   ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ*/
  22. #include    <Types.h>
  23.  
  24. #pragma        segment NUGG
  25.  
  26.  
  27.                                          /*ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  28.                                            Ñ                                        Ñ
  29.                                            Ñ    Structure showing the jump-trace    Ñ
  30.                                            Ñ    exception stack frame.                Ñ
  31.                                            Ñ                                        Ñ
  32.                                            ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ*/
  33. typedef struct {
  34.     short        status_register;
  35.     Ptr            program_counter;
  36.     short        vector_offset;
  37.     char        byte0;
  38.     char        byte1;
  39.     char        byte2;
  40.     char        byte3;
  41.     char        byte4;
  42.     char        byte5;
  43.     char        byte6;
  44.     char        byte7;
  45.     char        byte8;
  46.     char        byte9;
  47.     char        byte10;
  48.     char        byte11;
  49.     char        byte12;
  50.     char        byte13;
  51.     char        byte14;
  52.     char        byte15;
  53. } a_trap_stack_frame;
  54.  
  55.  
  56.  
  57.                                          /*ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  58.                                            Ñ                                        Ñ
  59.                                            Ñ    Comment Block.                        Ñ
  60.                                            Ñ                                        Ñ
  61.                                            ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ*/
  62. Ptr get_a_trap_exception_vector();
  63. void save_system_a_trap_vector(Ptr vector);
  64. void TAKE_A_TRAP_EXCEPTION_VECTOR();
  65.  
  66. Ptr        get_a_trap_stack_frame_program_counter(a_trap_stack_frame *frame);
  67. Ptr        GET_SAVED_A_TRAP_VECTOR();
  68. Handle    GET_MASTER_A_TRAP_HANDLE();
  69. void     SET_JUMP_TRACE_BIT();
  70. void    TAKE_JUMP_TRACE_VECTOR(long sludge_factor);
  71.  
  72.  
  73.  
  74. /*ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  75.   Ñ                                                                           Ñ
  76.   Ñ   Identifier:       start_sludging                                          Ñ
  77.   Ñ   -----------                                                             Ñ
  78.   Ñ                                                                           Ñ
  79.   Ñ       Description                                                         Ñ
  80.   Ñ       -----------                                                         Ñ
  81.   Ñ       This function starts the sludging.  It sets the jump-trace and       Ñ
  82.   Ñ          a-trap exceptions to SLUDGE routines and sets the jump-trace bit    Ñ
  83.   Ñ          in the status register.                                              Ñ
  84.   Ñ                                                                           Ñ
  85.   Ñ       History                                                             Ñ
  86.   Ñ       -------                                                             Ñ
  87.   Ñ                                                                           Ñ
  88.   Ñ       Author          Date            Description                         Ñ
  89.   Ñ       ------------------------------------------------------------------  Ñ
  90.   Ñ       Kevin McEntee   2/20/90         Original Implementation             Ñ
  91.   Ñ                                                                           Ñ
  92.   Ñ                                                                           Ñ
  93.   ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ*/
  94. void start_sludging(long sludge_factor)
  95. {                             
  96.     
  97.     save_system_a_trap_vector( get_a_trap_exception_vector() );  
  98.     
  99.     TAKE_JUMP_TRACE_VECTOR(sludge_factor);
  100.     TAKE_A_TRAP_EXCEPTION_VECTOR();    
  101.     SET_JUMP_TRACE_BIT(); 
  102. }
  103.  
  104.  
  105.  
  106.  
  107. /*ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  108.   Ñ                                                                           Ñ
  109.   Ñ   Identifier:      get_a_trap_exception_vector                             Ñ
  110.   Ñ   -----------                                                             Ñ
  111.   Ñ                                                                           Ñ
  112.   Ñ       Description                                                         Ñ
  113.   Ñ       -----------                                                         Ñ
  114.   Ñ       This function returns the current a-trap exception vector.          Ñ
  115.   Ñ                                                                           Ñ
  116.   Ñ       History                                                             Ñ
  117.   Ñ       -------                                                             Ñ
  118.   Ñ                                                                           Ñ
  119.   Ñ       Author          Date            Description                         Ñ
  120.   Ñ       ------------------------------------------------------------------  Ñ
  121.   Ñ       Kevin McEntee   2/20/90         Original Implementation             Ñ
  122.   Ñ                                                                           Ñ
  123.   Ñ                                                                           Ñ
  124.   ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ*/
  125. Ptr get_a_trap_exception_vector()
  126. {
  127.     Handle vector;
  128.     
  129.     
  130.     vector = (Handle) 0x28; 
  131.     
  132.     return( *vector);
  133.     
  134. }
  135.  
  136.  
  137.  
  138. /*ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  139.   Ñ                                                                           Ñ
  140.   Ñ   Identifier:       HLL_ATRAP_EX                                              Ñ
  141.   Ñ   -----------                                                             Ñ
  142.   Ñ                                                                           Ñ
  143.   Ñ       Description                                                         Ñ
  144.   Ñ       -----------                                                         Ñ
  145.   Ñ       HLL_ATRAP_EX stands for: High Level Language A-Trap Execution.      Ñ
  146.   Ñ          This function is called by SLUDGE's atrap exception handler and     Ñ
  147.   Ñ          returns the system value for the A-Trap exception handler, so the   Ñ
  148.   Ñ          system can process the trap.                                          Ñ
  149.   Ñ                                                                           Ñ
  150.   Ñ       History                                                             Ñ
  151.   Ñ       -------                                                             Ñ
  152.   Ñ                                                                           Ñ
  153.   Ñ       Author          Date            Description                         Ñ
  154.   Ñ       ------------------------------------------------------------------  Ñ
  155.   Ñ       Kevin McEntee   2/20/90         Original Implementation             Ñ
  156.   Ñ                                                                           Ñ
  157.   Ñ                                                                           Ñ
  158.   ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ*/
  159. Ptr        HLL_ATRAP_EX(Handle    register_A0, a_trap_stack_frame *frame)
  160. {
  161.     
  162.     return(GET_SAVED_A_TRAP_VECTOR());
  163. }
  164.  
  165.  
  166. /*ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  167.   Ñ                                                                           Ñ
  168.   Ñ   Identifier:      save_system_a_trap_vector                                  Ñ
  169.   Ñ   -----------                                                             Ñ
  170.   Ñ                                                                           Ñ
  171.   Ñ       Description                                                         Ñ
  172.   Ñ       -----------                                                         Ñ
  173.   Ñ       This function saves the system a-trap exception vector so we can    Ñ
  174.   Ñ          jump to it during a-trap processing.                                  Ñ
  175.   Ñ                                                                           Ñ
  176.   Ñ       History                                                             Ñ
  177.   Ñ       -------                                                             Ñ
  178.   Ñ                                                                           Ñ
  179.   Ñ       Author          Date            Description                         Ñ
  180.   Ñ       ------------------------------------------------------------------  Ñ
  181.   Ñ       Kevin McEntee   2/20/90         Original Implementation             Ñ
  182.   Ñ                                                                           Ñ
  183.   Ñ                                                                           Ñ
  184.   ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ*/
  185. void save_system_a_trap_vector(Ptr vector)
  186. {
  187.     Handle master_handle;
  188.     
  189.     master_handle = GET_MASTER_A_TRAP_HANDLE();
  190.     
  191.     *master_handle = vector;
  192. }
  193.  
  194.  
  195.  
  196.